/*
 *  COFF file handling for TCC
 * 
 *  Copyright (c) 2003, 2004 TK
 *  Copyright (c) 2004 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "tcc.h"
#include "i386-gen.h"

#include "coff.h"

extern int do_debug;

#define MAXNSCNS 255		/* MAXIMUM NUMBER OF SECTIONS         */
#define MAX_STR_TABLE 1000000
AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER       */
SCNHDR section_header[MAXNSCNS];

#define MAX_FUNCS 1000
#define MAX_FUNC_NAME_LENGTH 128

int nFuncs;
char Func[MAX_FUNCS][MAX_FUNC_NAME_LENGTH];
char AssociatedFile[MAX_FUNCS][MAX_FUNC_NAME_LENGTH];
int LineNoFilePtr[MAX_FUNCS];
int EndAddress[MAX_FUNCS];
int LastLineNo[MAX_FUNCS];
int FuncEntries[MAX_FUNCS];

BOOL OutputTheSection(Section * sect);
short int GetCoffFlags(const char *s);
void SortSymbolTable(void);
Section *FindSection(TCCState * s1, const char *sname);

int C67_main_entry_point;

int FindCoffSymbolIndex(const char *func_name);
int nb_syms;

typedef struct
{
	long tag;
	long size;
	long fileptr;
	long nextsym;
	short int dummy;
} AUXFUNC;

typedef struct
{
	long regmask;
	unsigned short lineno;
	unsigned short nentries;
	int localframe;
	int nextentry;
	short int dummy;
} AUXBF;

typedef struct
{
	long dummy;
	unsigned short lineno;
	unsigned short dummy1;
	int dummy2;
	int dummy3;
	unsigned short dummy4;
} AUXEF;

extern Section *symtab_section;
extern Section *stab_section, *stabstr_section;

int tcc_output_coff(TCCState *s1, FILE *f)
{
	Section *tcc_sect;
	SCNHDR *coff_sec;
	int file_pointer;
	char *Coff_str_table, *pCoff_str_table;
	int CoffTextSectionNo, coff_nb_syms;
	FILHDR file_hdr; /* FILE HEADER STRUCTURE              */
	Section *stext, *sdata, *sbss;
	int i, NSectionsToOutput = 0;

	stext = FindSection(s1, ".text");
	sdata = FindSection(s1, ".data");
	sbss = FindSection(s1, ".bss");

	nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
	coff_nb_syms = FindCoffSymbolIndex("XXXXXXXXXX1");

	file_hdr.f_magic = COFF_C67_MAGIC; /* magic number */
	file_hdr.f_timdat = 0; /* time & date stamp */
	file_hdr.f_opthdr = sizeof(AOUTHDR); /* sizeof(optional hdr) */
	file_hdr.f_flags = 0x1143; /* flags (copied from what code composer does) */
	file_hdr.f_TargetID = 0x99; /* for C6x = 0x0099 */

	o_filehdr.magic = 0x0108; /* see magic.h                          */
	o_filehdr.vstamp = 0x0190; /* version stamp                        */
	o_filehdr.tsize = stext->data_offset; /* text size in bytes, padded to FW bdry */
	o_filehdr.dsize = sdata->data_offset; /* initialized data "  "                */
	o_filehdr.bsize = sbss->data_offset; /* uninitialized data "   "             */
	o_filehdr.entrypt = C67_main_entry_point; /* entry pt.                          */
	o_filehdr.text_start = stext->sh_addr; /* base of text used for this file      */
	o_filehdr.data_start = sdata->sh_addr; /* base of data used for this file      */

	// create all the section headers

	file_pointer = FILHSZ + sizeof(AOUTHDR);

	CoffTextSectionNo = -1;

	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			NSectionsToOutput++;

			if (CoffTextSectionNo == -1 && tcc_sect == stext)
				CoffTextSectionNo = NSectionsToOutput; // rem which coff sect number the .text sect is

			strcpy(coff_sec->s_name, tcc_sect->name); /* section name */

			coff_sec->s_paddr = tcc_sect->sh_addr; /* physical address */
			coff_sec->s_vaddr = tcc_sect->sh_addr; /* virtual address */
			coff_sec->s_size = tcc_sect->data_offset; /* section size */
			coff_sec->s_scnptr = 0; /* file ptr to raw data for section */
			coff_sec->s_relptr = 0; /* file ptr to relocation */
			coff_sec->s_lnnoptr = 0; /* file ptr to line numbers */
			coff_sec->s_nreloc = 0; /* number of relocation entries */
			coff_sec->s_flags = GetCoffFlags(coff_sec->s_name); /* flags */
			coff_sec->s_reserved = 0; /* reserved byte */
			coff_sec->s_page = 0; /* memory page id */

			file_pointer += sizeof(SCNHDR);
		}
	}

	file_hdr.f_nscns = NSectionsToOutput; /* number of sections */

	// now loop through and determine file pointer locations
	// for the raw data


	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			// put raw data
			coff_sec->s_scnptr = file_pointer; /* file ptr to raw data for section */
			file_pointer += coff_sec->s_size;
		}
	}

	// now loop through and determine file pointer locations
	// for the relocation data

	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			// put relocations data
			if (coff_sec->s_nreloc > 0)
			{
				coff_sec->s_relptr = file_pointer; /* file ptr to relocation */
				file_pointer += coff_sec->s_nreloc * sizeof(struct reloc);
			}
		}
	}

	// now loop through and determine file pointer locations
	// for the line number data

	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		coff_sec->s_nlnno = 0;
		coff_sec->s_lnnoptr = 0;

		if (do_debug && tcc_sect == stext)
		{
			// count how many line nos data

			// also find association between source file name and function
			// so we can sort the symbol table


			Stab_Sym *sym, *sym_end;
			char func_name[MAX_FUNC_NAME_LENGTH],
					last_func_name[MAX_FUNC_NAME_LENGTH];
			unsigned long func_addr, last_pc, pc;
			const char *incl_files[INCLUDE_STACK_SIZE];
			int incl_index, len, last_line_num;
			const char *str, *p;

			coff_sec->s_lnnoptr = file_pointer; /* file ptr to linno */

			func_name[0] = '\0';
			func_addr = 0;
			incl_index = 0;
			last_func_name[0] = '\0';
			last_pc = 0xffffffff;
			last_line_num = 1;
			sym = (Stab_Sym *) stab_section->data + 1;
			sym_end = (Stab_Sym *) (stab_section->data
					+ stab_section->data_offset);

			nFuncs = 0;
			while (sym < sym_end)
			{
				switch (sym->n_type)
				{
				/* function start or end */
				case N_FUN:
					if (sym->n_strx == 0)
					{
						// end of function

						coff_sec->s_nlnno++;
						file_pointer += LINESZ;

						pc = sym->n_value + func_addr;
						func_name[0] = '\0';
						func_addr = 0;
						EndAddress[nFuncs] = pc;
						FuncEntries[nFuncs] = (file_pointer
								- LineNoFilePtr[nFuncs]) / LINESZ - 1;
						LastLineNo[nFuncs++] = last_line_num + 1;
					}
					else
					{
						// beginning of function

						LineNoFilePtr[nFuncs] = file_pointer;
						coff_sec->s_nlnno++;
						file_pointer += LINESZ;

						str = (const char *) stabstr_section->data
								+ sym->n_strx;

						p = strchr(str, ':');
						if (!p)
						{
							pstrcpy(func_name, sizeof(func_name), str);
							pstrcpy(Func[nFuncs], sizeof(func_name), str);
						}
						else
						{
							len = p - str;
							if (len > sizeof(func_name) - 1)
								len = sizeof(func_name) - 1;
							memcpy(func_name, str, len);
							memcpy(Func[nFuncs], str, len);
							func_name[len] = '\0';
						}

						// save the file that it came in so we can sort later
						pstrcpy(AssociatedFile[nFuncs], sizeof(func_name),
								incl_files[incl_index - 1]);

						func_addr = sym->n_value;
					}
					break;

					/* line number info */
				case N_SLINE:
					pc = sym->n_value + func_addr;

					last_pc = pc;
					last_line_num = sym->n_desc;

					/* XXX: slow! */
					strcpy(last_func_name, func_name);

					coff_sec->s_nlnno++;
					file_pointer += LINESZ;
					break;
					/* include files */
				case N_BINCL:
					str = (const char *) stabstr_section->data + sym->n_strx;
					add_incl: if (incl_index < INCLUDE_STACK_SIZE)
					{
						incl_files[incl_index++] = str;
					}
					break;
				case N_EINCL:
					if (incl_index > 1)
						incl_index--;
					break;
				case N_SO:
					if (sym->n_strx == 0)
					{
						incl_index = 0; /* end of translation unit */
					}
					else
					{
						str = (const char *) stabstr_section->data
								+ sym->n_strx;
						/* do not add path */
						len = strlen(str);
						if (len > 0 && str[len - 1] != '/')
							goto add_incl;
					}
					break;
				}
				sym++;
			}
		}

	}

	file_hdr.f_symptr = file_pointer; /* file pointer to symtab */

	if (do_debug)
		file_hdr.f_nsyms = coff_nb_syms; /* number of symtab entries */
	else
		file_hdr.f_nsyms = 0;

	file_pointer += file_hdr.f_nsyms * SYMNMLEN;

	// OK now we are all set to write the file


	fwrite(&file_hdr, FILHSZ, 1, f);
	fwrite(&o_filehdr, sizeof(o_filehdr), 1, f);

	// write section headers
	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			fwrite(coff_sec, sizeof(SCNHDR), 1, f);
		}
	}

	// write raw data
	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			fwrite(tcc_sect->data, tcc_sect->data_offset, 1, f);
		}
	}

	// write relocation data
	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (OutputTheSection(tcc_sect))
		{
			// put relocations data
			if (coff_sec->s_nreloc > 0)
			{
				fwrite(tcc_sect->reloc, coff_sec->s_nreloc
						* sizeof(struct reloc), 1, f);
			}
		}
	}

	// group the symbols in order of filename, func1, func2, etc
	// finally global symbols

	if (do_debug)
		SortSymbolTable();

	// write line no data

	for (i = 1; i < s1->nb_sections; i++)
	{
		coff_sec = &section_header[i];
		tcc_sect = s1->sections[i];

		if (do_debug && tcc_sect == stext)
		{
			// count how many line nos data


			Stab_Sym *sym, *sym_end;
			char func_name[128], last_func_name[128];
			unsigned long func_addr, last_pc, pc;
			const char *incl_files[INCLUDE_STACK_SIZE];
			int incl_index, len, last_line_num;
			const char *str, *p;
			LINENO CoffLineNo;

			func_name[0] = '\0';
			func_addr = 0;
			incl_index = 0;
			last_func_name[0] = '\0';
			last_pc = 0;
			last_line_num = 1;
			sym = (Stab_Sym *) stab_section->data + 1;
			sym_end = (Stab_Sym *) (stab_section->data
					+ stab_section->data_offset);

			while (sym < sym_end)
			{
				switch (sym->n_type)
				{
				/* function start or end */
				case N_FUN:
					if (sym->n_strx == 0)
					{
						// end of function

						CoffLineNo.l_addr.l_paddr = last_pc;
						CoffLineNo.l_lnno = last_line_num + 1;
						fwrite(&CoffLineNo, 6, 1, f);

						pc = sym->n_value + func_addr;
						func_name[0] = '\0';
						func_addr = 0;
					}
					else
					{
						// beginning of function

						str = (const char *) stabstr_section->data
								+ sym->n_strx;

						p = strchr(str, ':');
						if (!p)
						{
							pstrcpy(func_name, sizeof(func_name), str);
						}
						else
						{
							len = p - str;
							if (len > sizeof(func_name) - 1)
								len = sizeof(func_name) - 1;
							memcpy(func_name, str, len);
							func_name[len] = '\0';
						}
						func_addr = sym->n_value;
						last_pc = func_addr;
						last_line_num = -1;

						// output a function begin

						CoffLineNo.l_addr.l_symndx = FindCoffSymbolIndex(
								func_name);
						CoffLineNo.l_lnno = 0;

						fwrite(&CoffLineNo, 6, 1, f);
					}
					break;

					/* line number info */
				case N_SLINE:
					pc = sym->n_value + func_addr;

					/* XXX: slow! */
					strcpy(last_func_name, func_name);

					// output a line reference

					CoffLineNo.l_addr.l_paddr = last_pc;

					if (last_line_num == -1)
					{
						CoffLineNo.l_lnno = sym->n_desc;
					}
					else
					{
						CoffLineNo.l_lnno = last_line_num + 1;
					}

					fwrite(&CoffLineNo, 6, 1, f);

					last_pc = pc;
					last_line_num = sym->n_desc;

					break;

					/* include files */
				case N_BINCL:
					str = (const char *) stabstr_section->data + sym->n_strx;
					add_incl2: if (incl_index < INCLUDE_STACK_SIZE)
					{
						incl_files[incl_index++] = str;
					}
					break;
				case N_EINCL:
					if (incl_index > 1)
						incl_index--;
					break;
				case N_SO:
					if (sym->n_strx == 0)
					{
						incl_index = 0; /* end of translation unit */
					}
					else
					{
						str = (const char *) stabstr_section->data
								+ sym->n_strx;
						/* do not add path */
						len = strlen(str);
						if (len > 0 && str[len - 1] != '/')
							goto add_incl2;
					}
					break;
				}
				sym++;
			}
		}
	}

	// write symbol table
	if (do_debug)
	{
		int k;
		struct syment csym;
		AUXFUNC auxfunc;
		AUXBF auxbf;
		AUXEF auxef;
		int i;
		Elf32_Sym *p;
		const char *name;
		int nstr;
		int n = 0;

		Coff_str_table = (char *) tcc_malloc(MAX_STR_TABLE);
		pCoff_str_table = Coff_str_table;
		nstr = 0;

		p = (Elf32_Sym *) symtab_section->data;

		for (i = 0; i < nb_syms; i++)
		{

			name = symtab_section->link->data + p->st_name;

			for (k = 0; k < 8; k++)
				csym._n._n_name[k] = 0;

			if (strlen(name) <= 8)
			{
				strcpy(csym._n._n_name, name);
			}
			else
			{
				if (pCoff_str_table - Coff_str_table + strlen(name)
						> MAX_STR_TABLE - 1)
					error("String table too large");

				csym._n._n_n._n_zeroes = 0;
				csym._n._n_n._n_offset = pCoff_str_table - Coff_str_table + 4;

				strcpy(pCoff_str_table, name);
				pCoff_str_table += strlen(name) + 1; // skip over null
				nstr++;
			}

			if (p->st_info == 4)
			{
				// put a filename symbol
				csym.n_value = 33; // ?????
				csym.n_scnum = N_DEBUG;
				csym.n_type = 0;
				csym.n_sclass = C_FILE;
				csym.n_numaux = 0;
				fwrite(&csym, 18, 1, f);
				n++;

			}
			else if (p->st_info == 0x12)
			{
				// find the function data

				for (k = 0; k < nFuncs; k++)
				{
					if (strcmp(name, Func[k]) == 0)
						break;
				}

				if (k >= nFuncs)
				{
					char s[256];

					sprintf(s, "debug info can't find function: %s", name);

					error(s);
				}
				// put a Function Name

				csym.n_value = p->st_value; // physical address
				csym.n_scnum = CoffTextSectionNo;
				csym.n_type = MKTYPE(T_INT, DT_FCN, 0, 0, 0, 0, 0);
				csym.n_sclass = C_EXT;
				csym.n_numaux = 1;
				fwrite(&csym, 18, 1, f);

				// now put aux info

				auxfunc.tag = 0;
				auxfunc.size = EndAddress[k] - p->st_value;
				auxfunc.fileptr = LineNoFilePtr[k];
				auxfunc.nextsym = n + 6; // tktk
				auxfunc.dummy = 0;
				fwrite(&auxfunc, 18, 1, f);

				// put a .bf

				strcpy(csym._n._n_name, ".bf");
				csym.n_value = p->st_value; // physical address
				csym.n_scnum = CoffTextSectionNo;
				csym.n_type = 0;
				csym.n_sclass = C_FCN;
				csym.n_numaux = 1;
				fwrite(&csym, 18, 1, f);

				// now put aux info

				auxbf.regmask = 0;
				auxbf.lineno = 0;
				auxbf.nentries = FuncEntries[k];
				auxbf.localframe = 0;
				auxbf.nextentry = n + 6;
				auxbf.dummy = 0;
				fwrite(&auxbf, 18, 1, f);

				// put a .ef

				strcpy(csym._n._n_name, ".ef");
				csym.n_value = EndAddress[k]; // physical address
				csym.n_scnum = CoffTextSectionNo;
				csym.n_type = 0;
				csym.n_sclass = C_FCN;
				csym.n_numaux = 1;
				fwrite(&csym, 18, 1, f);

				// now put aux info

				auxef.dummy = 0;
				auxef.lineno = LastLineNo[k];
				auxef.dummy1 = 0;
				auxef.dummy2 = 0;
				auxef.dummy3 = 0;
				auxef.dummy4 = 0;
				fwrite(&auxef, 18, 1, f);

				n += 6;

			}
			else
			{
				// try an put some type info

				if ((p->st_other & VT_BTYPE) == VT_DOUBLE)
				{
					csym.n_type = T_DOUBLE; // int
					csym.n_sclass = C_EXT;
				}
				else if ((p->st_other & VT_BTYPE) == VT_FLOAT)
				{
					csym.n_type = T_FLOAT;
					csym.n_sclass = C_EXT;
				}
				else if ((p->st_other & VT_BTYPE) == VT_INT)
				{
					csym.n_type = T_INT; // int
					csym.n_sclass = C_EXT;
				}
				else if ((p->st_other & VT_BTYPE) == VT_SHORT)
				{
					csym.n_type = T_SHORT;
					csym.n_sclass = C_EXT;
				}
				else if ((p->st_other & VT_BTYPE) == VT_BYTE)
				{
					csym.n_type = T_CHAR;
					csym.n_sclass = C_EXT;
				}
				else
				{
					csym.n_type = T_INT; // just mark as a label
					csym.n_sclass = C_LABEL;
				}

				csym.n_value = p->st_value;
				csym.n_scnum = 2;
				csym.n_numaux = 1;
				fwrite(&csym, 18, 1, f);

				auxfunc.tag = 0;
				auxfunc.size = 0x20;
				auxfunc.fileptr = 0;
				auxfunc.nextsym = 0;
				auxfunc.dummy = 0;
				fwrite(&auxfunc, 18, 1, f);
				n++;
				n++;

			}

			p++;
		}
	}

	if (do_debug)
	{
		// write string table

		// first write the size
		i = pCoff_str_table - Coff_str_table;
		fwrite(&i, 4, 1, f);

		// then write the strings
		fwrite(Coff_str_table, i, 1, f);

		tcc_free(Coff_str_table);
	}

	return 0;
}

// group the symbols in order of filename, func1, func2, etc
// finally global symbols

void SortSymbolTable(void)
{
	int i, j, k, n = 0;
	Elf32_Sym *p, *p2, *NewTable;
	char *name, *name2;

	NewTable = (Elf32_Sym *) tcc_malloc(nb_syms * sizeof(Elf32_Sym));

	p = (Elf32_Sym *) symtab_section->data;

	// find a file symbol, copy it over
	// then scan the whole symbol list and copy any function
	// symbols that match the file association

	for (i = 0; i < nb_syms; i++)
	{
		if (p->st_info == 4)
		{
			name = (char *) symtab_section->link->data + p->st_name;

			// this is a file symbol, copy it over

			NewTable[n++] = *p;

			p2 = (Elf32_Sym *) symtab_section->data;

			for (j = 0; j < nb_syms; j++)
			{
				if (p2->st_info == 0x12)
				{
					// this is a func symbol

					name2 = (char *) symtab_section->link->data + p2->st_name;

					// find the function data index

					for (k = 0; k < nFuncs; k++)
					{
						if (strcmp(name2, Func[k]) == 0)
							break;
					}

					if (k >= nFuncs)
					{
						char s[256];

						sprintf(s, "debug (sort) info can't find function: %s",
								name2);

						error(s);
					}

					if (strcmp(AssociatedFile[k], name) == 0)
					{
						// yes they match copy it over

						NewTable[n++] = *p2;
					}
				}
				p2++;
			}
		}
		p++;
	}

	// now all the filename and func symbols should have been copied over
	// copy all the rest over (all except file and funcs)

	p = (Elf32_Sym *) symtab_section->data;
	for (i = 0; i < nb_syms; i++)
	{
		if (p->st_info != 4 && p->st_info != 0x12)
		{
			NewTable[n++] = *p;
		}
		p++;
	}

	if (n != nb_syms)
		error("Internal Compiler error, debug info");

	// copy it all back

	p = (Elf32_Sym *) symtab_section->data;
	for (i = 0; i < nb_syms; i++)
	{
		*p++ = NewTable[i];
	}

	tcc_free(NewTable);
}

int FindCoffSymbolIndex(const char *func_name)
{
	int i, n = 0;
	Elf32_Sym *p;
	char *name;

	p = (Elf32_Sym *) symtab_section->data;

	for (i = 0; i < nb_syms; i++)
	{

		name = (char *) symtab_section->link->data + p->st_name;

		if (p->st_info == 4)
		{
			// put a filename symbol
			n++;
		}
		else if (p->st_info == 0x12)
		{

			if (strcmp(func_name, name) == 0)
				return n;

			n += 6;

			// put a Function Name

			// now put aux info

			// put a .bf

			// now put aux info

			// put a .ef

			// now put aux info

		}
		else
		{
			n += 2;
		}

		p++;
	}

	return n; // total number of symbols
}

BOOL OutputTheSection(Section * sect)
{
	const char *s = sect->name;

	if (!strcmp(s, ".text"))
		return true;
	else if (!strcmp(s, ".data"))
		return true;
	else
		return 0;
}

short int GetCoffFlags(const char *s)
{
	if (!strcmp(s, ".text"))
		return STYP_TEXT | STYP_DATA | STYP_ALIGN | 0x400;
	else if (!strcmp(s, ".data"))
		return STYP_DATA;
	else if (!strcmp(s, ".bss"))
		return STYP_BSS;
	else if (!strcmp(s, ".stack"))
		return STYP_BSS | STYP_ALIGN | 0x200;
	else if (!strcmp(s, ".cinit"))
		return STYP_COPY | STYP_DATA | STYP_ALIGN | 0x200;
	else
		return 0;
}

Section *FindSection(TCCState * s1, const char *sname)
{
	Section *s;
	int i;

	for (i = 1; i < s1->nb_sections; i++)
	{
		s = s1->sections[i];

		if (!strcmp(sname, s->name))
			return s;
	}

	error("could not find section %s", sname);
	return 0;
}

int tcc_load_coff(TCCState * s1, int fd)
{
	// tktk TokenSym *ts;

	FILE *f;
	unsigned int str_size;
	char *Coff_str_table, *name;
	int i, k;
	struct syment csym;
	char name2[9];
	FILHDR file_hdr; /* FILE HEADER STRUCTURE              */

	f = fdopen(fd, "rb");
	if (!f)
	{
		error("Unable to open .out file for input");
	}

	if (fread(&file_hdr, FILHSZ, 1, f) != 1)
		error("error reading .out file for input");

	if (fread(&o_filehdr, sizeof(o_filehdr), 1, f) != 1)
		error("error reading .out file for input");

	// first read the string table

	if (fseek(f, file_hdr.f_symptr + file_hdr.f_nsyms * SYMESZ, SEEK_SET))
		error("error reading .out file for input");

	if (fread(&str_size, sizeof(int), 1, f) != 1)
		error("error reading .out file for input");

	Coff_str_table = (char *) tcc_malloc(str_size);

	if (fread(Coff_str_table, str_size - 4, 1, f) != 1)
		error("error reading .out file for input");

	// read/process all the symbols

	// seek back to symbols

	if (fseek(f, file_hdr.f_symptr, SEEK_SET))
		error("error reading .out file for input");

	for (i = 0; i < file_hdr.f_nsyms; i++)
	{
		if (fread(&csym, SYMESZ, 1, f) != 1)
			error("error reading .out file for input");

		if (csym._n._n_n._n_zeroes == 0)
		{
			name = Coff_str_table + csym._n._n_n._n_offset - 4;
		}
		else
		{
			name = csym._n._n_name;

			if (name[7] != 0)
			{
				for (k = 0; k < 8; k++)
					name2[k] = name[k];

				name2[8] = 0;

				name = name2;
			}
		}
		//              if (strcmp("_DAC_Buffer",name)==0)  // tktk
		//                      name[0]=0;

		if (((csym.n_type & 0x30) == 0x20 && csym.n_sclass == 0x2)
				|| ((csym.n_type & 0x30) == 0x30 && csym.n_sclass == 0x2)
				|| (csym.n_type == 0x4 && csym.n_sclass == 0x2) || (csym.n_type
				== 0x8 && csym.n_sclass == 0x2) || // structures
				(csym.n_type == 0x18 && csym.n_sclass == 0x2) || // pointer to structure
				(csym.n_type == 0x7 && csym.n_sclass == 0x2) || // doubles
				(csym.n_type == 0x6 && csym.n_sclass == 0x2)) // floats
		{
			// strip off any leading underscore (except for other main routine)

			if (name[0] == '_' && strcmp(name, "_main") != 0)
				name++;

			tcc_add_symbol(s1, name, csym.n_value);
		}
		// skip any aux records

		if (csym.n_numaux == 1)
		{
			if (fread(&csym, SYMESZ, 1, f) != 1)
				error("error reading .out file for input");
			i++;
		}
	}

	return 0;
}
